package net.lzzy.practices.services;

import net.lzzy.practices.constants.Messages;
import net.lzzy.practices.entities.Course;
import net.lzzy.practices.entities.User;
import net.lzzy.practices.repositories.CourseRepository;
import net.lzzy.practices.utils.JwtUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.PageRequest;
import org.springframework.stereotype.Service;

import java.util.Date;
import java.util.List;
import java.util.UUID;
@Service
public class CourseServicesImpl implements CourseService {
    private final CourseRepository repository;

    @Autowired
    public CourseServicesImpl(CourseRepository repository) {
        this.repository = repository;
    }

    /**
     * 获取所有课程
     *
     * @return 课程集合
     */
    @Override
    public List<Course> get() {
        return repository.findAllByOrderByUpdateTimeDesc();
    }

    /**
     * 分页获取所有课程
     *
     * @param page 页码
     * @param size 每页大小
     * @return 当前页课程集合
     */
    @Override
    public List<Course> get(int page, int size) {
        return repository.findAllByOrderByUpdateTimeDesc(PageRequest.of(page, size));
    }

    /**
     * 获取所有开放/未开放的课程
     *
     * @param open 是否开放课程
     * @return 符合条件的课程集合
     */
    @Override
    public List<Course> get(boolean open) {
        return repository.findCoursesByOpenIsOrderByUpdateTimeDesc(open);
    }

    /**
     * 分页获取开放/未开放的课程
     *
     * @param page 页码
     * @param size 每页大小
     * @param open 是否开放
     * @return 福特条件的当前页码课程集合
     */
    @Override
    public List<Course> get(int page, int size, boolean open) {
        return repository.findCoursesByOpenIsOrderByUpdateTimeDesc(PageRequest.of(page, size),open);
    }

    /**
     * 课程数量
     *
     * @return 课程数量
     */
    @Override
    public Integer count() {
        return repository.countAllBy();
    }

    /**
     * 开放/未开放课程数量
     *
     * @param open 是否开放
     * @return 课程数量
     */
    @Override
    public Integer count(boolean open) {
        return repository.countCoursesByOpenIs(open);
    }

    /**
     * 根据id获取课程对象
     *
     * @param id 课程id
     * @return 课程对象
     */
    @Override
    public Course getById(UUID id) {
        return repository.findById(id).orElse(null);
    }

    /**
     * 获取某教师的所有课程
     *
     * @param teacherId 教师id
     * @return 课程集合
     */
//    @Override
//    public List<Course> getTeachersCourses(UUID teacherId) {
//        return Collections.emptyList();
//    }

    /**
     * 获取某学生的所有课程
     *
     * @param studentId 学生id
     * @return 课程集合
     */
//    @Override
//    public List<Course> getStudentsCourses(UUID studentId) {
//        return Collections.emptyList();
//    }

    /**
     * 获取某教师的所有课程
     *
     * @param teacherId 教师id
     * @return 课程集合
     */
    @Override
    public List<Course> getTeachersCourses(UUID teacherId) {
        return repository.findCoursesByTeacherIdEqualsOrderByCreateTime(teacherId);
    }

    /**
     * 获取某学生的所有课程
     *
     * @param studentId 学生id
     * @return 课程集合
     */
    @Override
    public List<Course> getStudentsCourses(UUID studentId) {
        User student = new User();
        student.setId(studentId);
        return repository.findCoursesByStudentsContainsAndOpenOrderByUpdateTimeDesc(student,true);
    }

    /**
     * 教师创建新课程
     *
     * @param course 新课程对象
     * @return 创建好的课程对象
     */
    @Override
    public Course add(Course course) {
        return repository.save(course);
    }

    /**
     * 更新课程
     *
     * @param course 课程对象
     * @param token  操作人令牌
     * @return 更新后的课程对象
     */
    @Override
    public Course update(Course course, String token) {
        UUID teacherId = course.getTeacher().getId();
        if(!teacherId.toString().equals(JwtUtil.verifyToken(token))){
            return null;
        }
        course.setUpdateTime(new Date());
        return repository.save(course);
    }

    /**
     * 课程创建者开放/关闭课程
     *
     * @param id 课程对象
     * @param token  操作人令牌
     * @return 操作后的课程对象
     */
    @Override
    public Course openCloseCourse(UUID id,boolean open, String token) {
        Course course = repository.findById(id).orElse(null);
        if(course != null){
            course.setOpen(open);
            return update(course,token);
        }

        return null;
    }

    /**
     * 删除课程
     *
     * @param id    要删除的课程id
     * @param token 操作人令牌
     * @return 删除成功与否的消息
     */
    @Override
    public Messages remove(UUID id, String token) {

        Course course= repository.findById(id).orElse(null);
        if(course == null){
            return Messages.WRONG_ID;
        }
        UUID tenantId = course.getTeacher().getId();
        if(!tenantId.toString().equals(JwtUtil.verifyToken(token))) {
            return Messages.NO_PERMISSION;
        }
        if (course.getChapters().size() > 0 || course.getStudents().size() > 0 || course.getApplicants().size() > 0){
            return Messages.RELATED_DATA;
        }
        repository.delete(course);
        return Messages.SUCCESS;
    }
}
